package faw.car.ccenter;

import android.os.RemoteCallbackList;
import android.os.RemoteException;

public class CarSceneModeManager extends ICarCCenter.Stub {
    private static final String TAG = "ws06_CarSceneModeManager";
    private final ICarSceneModeManagerSDK mICarSceneModeManagerSDK;
    private final RemoteCallbackList<ICarSceneModeChangedListener>
            mCarSceneModeChangedListenerList = new RemoteCallbackList<>();
    private final RemoteCallbackList<ICarSceneModeChangedListener>
            mCarCCenterManagerListenerList = new RemoteCallbackList<>();
    private ICarSceneModeChangedListener iCarSceneModeChangedListener;
    private final String mPackageName = "CarSceneModeManager";
    private final Lock mLock = new ReentrantLock();

    public CarSceneModeManager() {
        HQLog.i(TAG, "CarSceneModeManager constructor...");
        mICarSceneModeManagerSDK = QISISdkFactory.createCarSceneModeManagerProxy();
        if (mICarSceneModeManagerSDK == null) {
            HQLog.e(TAG, "mICarSceneModeManagerSDK NULL! CarSceneModeManager init Failed!!");
            return;
        }
        try {
            initSceneModeListener();
            HQLog.i(TAG, "CarSceneModeManager constructor success.");
        } catch (Exception e) {
            HQLog.e(TAG, "CarSceneModeManager Error:" + e.getMessage());
            e.printStackTrace();
        }
    }

    public void destroy() {
        if (mCarSceneModeChangedListenerList != null) {
            HQLog.e(TAG, "**** mCarSceneModeChangedListenerList destroy! ****");
            mCarSceneModeChangedListenerList.kill();
        }
        if (mICarSceneModeManagerSDK != null) {
            mICarSceneModeManagerSDK.unregisterSceneModeListener(mPackageName);
        }
    }

    private void initSceneModeListener() {
        HQLog.i(TAG, "CarSceneModeManager initSceneModeListener.");
        final ICarSceneModeListener carSceneModeListener = new ICarSceneModeListener() {

            @Override
            public void onWindowStateChanged(WindowState windowState) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onWindowStateChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onWindowStateChanged(windowState);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onWindowStateChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onUpDownAdjustDataChanged(UpDownMoveData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onUpDownAdjustDataChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onUpDownAdjustDataChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onUpDownAdjustDataChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onFrontRearAdjustDataChanged(FrontRearMoveData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onFrontRearAdjustDataChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onFrontRearAdjustDataChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onFrontRearAdjustDataChanged SceneMode Exception:"
                            + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onBackrestAngleAdjustDataChanged(BackrestAngleAdjustData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onBackrestAngleAdjustDataChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onBackrestAngleAdjustDataChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onBackrestAngleAdjustDataChanged SceneMode Exception: "
                            + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onCushionAdjustDataChanged(CushionAdjustData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onCushionAdjustDataChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onCushionAdjustDataChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onCushionAdjustDataChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onAutoLightStatusChanged(int status) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onAutoLightStatusChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onAutoLightStatusChanged(status);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onAutoLightStatusChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onHeatInfoDataChanged(HeatInfoData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onHeatInfoDataChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onHeatInfoDataChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onHeatInfoDataChanged SceneMode Exception:" + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onSeatVentInfoChanged(VentInfoData data) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onSeatVentInfoChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onSeatVentInfoChanged(data);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onSeatVentInfoChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onRemoteACStateChanged(SeatPosition position, int status) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onRemoteACStateChanged ListenerList.COUNT:"
                            + COUNT + ", status:" + status);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onRemoteACStateChanged(position.getValue(), status);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onRemoteACStateChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }


            @Override
            public void onSeatPositionMemoryStatusChanged(SeatPosition position, int result) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onSeatPositionMemoryStatusChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onSeatPositionMemoryStatusChanged(position.getValue(), result);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onSeatPositionMemoryStatusChanged SceneMode Exception: "
                            + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onHandrailSceneModeStateChanged(int state) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onHandrailSceneModeStateChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onHandrailSceneModeStateChanged(state);
                        }
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onHandrailSceneModeStateChanged -- Exception:" + e.getMessage());
                    e.printStackTrace();
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onScreenFoldStateChanged(int state) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onScreenFoldStateChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onScreenFoldStateChanged(state);
                        }
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onScreenFoldStateChanged -- Exception:" + e.getMessage());
                    e.printStackTrace();
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onScreenFoldConditionFailed(int source, int reason) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onScreenFoldConditionFailed ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onScreenFoldConditionFailed(source, reason);
                        }
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onScreenFoldConditionFailed -- Exception:" + e.getMessage());
                    e.printStackTrace();
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onScreenFoldDisableStateChanged(int status) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onScreenFoldDisableStateChanged ListenerList.COUNT:"
                            + COUNT);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onScreenFoldDisableStateChanged(status);
                        }
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onScreenFoldDisableStateChanged -- Exception:" + e.getMessage());
                    e.printStackTrace();
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public void onRemoteACStatusChanged(SeatPosition position,  RemotFeedbackACState state) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onRemoteACStatusChanged ListenerList.COUNT:"
                            + COUNT + ", state:" + state);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onRemoteACStatusChanged(position.getValue(), state);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onRemoteACStatusChanged SceneMode Exception: " + e.getMessage());
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }

            @Override
            public int onSceneModeSetRequest(int status) {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onSceneModeSetRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onSceneModeSetRequest(status);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onSceneModeSetRequest Exception: " + e.getMessage());
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onPlayWakeupMusicRequest(int status) {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onPlayWakeupMusicRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onPlayWakeupMusicRequest(status);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onPlayWakeupMusicRequest Exception: " + e.getMessage());
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onPlaySleepMusicRequest(int status) {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onPlaySleepMusicRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onPlaySleepMusicRequest(status);
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    HQLog.e(TAG, "onPlaySleepMusicRequest Exception: " + e.getMessage());
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onSceneModeStatusRequest() {
                try {
                    if (iCarSceneModeChangedListener != null) {
                        int retVal = iCarSceneModeChangedListener.onSceneModeStatusRequest();
                        HQLog.i(TAG, "ICarSceneModeListener onSceneModeStatusRequest, reVal:" + retVal);
                        return retVal;
                    } else {
                        HQLog.e(TAG, "onSceneModeStatusRequest iCarSceneModeChangedListener NULL!");
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onSceneModeStatusRequest Exception:" + e.getMessage());
                    e.printStackTrace();
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onBonusEggStatusRequest() {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onBonusEggStatusRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onBonusEggStatusRequest();
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onBonusEggStatusRequest Exception:" + e.getMessage());
                    e.printStackTrace();
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onSleepMusicStatusRequest() {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onSleepMusicStatusRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onSleepMusicStatusRequest();
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onSleepMusicStatusRequest Exception:" + e.getMessage());
                    e.printStackTrace();
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onWakeUpMusicStatusRequest() {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onWakeUpMusicStatusRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onWakeUpMusicStatusRequest();
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onWakeUpMusicStatusRequest Exception:" + e.getMessage());
                    e.printStackTrace();
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public int onWakeUpDurationRequest() {
                try {
                    HQLog.i(TAG, "ICarSceneModeListener onWakeUpDurationRequest");
                    if (iCarSceneModeChangedListener != null) {
                        return iCarSceneModeChangedListener.onWakeUpDurationRequest();
                    }
                } catch (Exception e) {
                    HQLog.e(TAG, "onWakeUpDurationRequest Exception:" + e.getMessage());
                    e.printStackTrace();
                }
                return Constants.RETURN_INT_INVALID;
            }

            @Override
            public void onSeatOccupyStatusChanged(SeatPosition position, int status) {
                try {
                    mLock.lock();
                    int COUNT = mCarSceneModeChangedListenerList.beginBroadcast();
                    HQLog.i(TAG, "ICarSceneModeListener onSeatOccupyStatusChanged ListenerList.COUNT:"
                            + COUNT + ", position:" + position + ", status:" + status);
                    for (int x = 0; x < COUNT; x++) {
                        ICarSceneModeChangedListener item = mCarSceneModeChangedListenerList.getBroadcastItem(x);
                        if (item != null) {
                            item.onSeatOccupyStatusChanged(position.getValue(), status);
                        }
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    mCarSceneModeChangedListenerList.finishBroadcast();
                    mLock.unlock();
                }
            }
        };
        mICarSceneModeManagerSDK.registerSceneModeListener(mPackageName, carSceneModeListener);
    }

    @Override
    public int setWindowState(WindowState state) throws RemoteException {
        HQLog.d(TAG, "setWindowState state:" + state);
        return mICarSceneModeManagerSDK.setWindowState(state);
    }

    @Override
    public CarWindowData getWindowState(int position) throws RemoteException {
        return mICarSceneModeManagerSDK.getWindowState(SeatPosition.valueOf(position));
    }

    @Override
    public void registerSceneModeChangedListener(ICarSceneModeChangedListener listener) throws RemoteException {
        HQLog.i(TAG, "registerSceneModeChangedListener +++listener:" + listener.toString());
        mCarSceneModeChangedListenerList.register(listener);
    }

    @Override
    public void unregisterSceneModeChangedListener(ICarSceneModeChangedListener listener) throws RemoteException {
        HQLog.i(TAG, "registerSceneModeChangedListener ---listener:" + listener.toString());
        mCarSceneModeChangedListenerList.unregister(listener);
    }

    @Override
    public int setDCChargePortStatus(int taskID, int status) throws RemoteException {
        HQLog.d(TAG, "setDCChargePortStatus taskID:" + taskID + ", status:" + status);
        return mICarSceneModeManagerSDK.setDCChargePortStatus(taskID, status);
    }

    @Override
    public int setACChargePortStatus(int taskID, int status) throws RemoteException {
        HQLog.d(TAG, "setACChargePortStatus taskID:" + taskID + ",status:" + status);
        return mICarSceneModeManagerSDK.setACChargePortStatus(taskID, status);
    }

    @Override
    public int setRearMirrorFoldState(int position, int taskID, int status) throws RemoteException {
        HQLog.d(TAG, "setRearMirrorFoldState position:" + position + ", taskID:" + taskID + ", status:" + status);
        return mICarSceneModeManagerSDK.setRearMirrorFoldState(SeatPosition.valueOf(position), taskID, status);
    }

    @Override
    public int setRearMirrorHeatState(int position, int taskID, int status) throws RemoteException {
        HQLog.d(TAG, "setRearMirrorHeatState position:" + position + ", taskID:" + taskID + ", status:" + status);
        return mICarSceneModeManagerSDK.setRearMirrorHeatState(SeatPosition.valueOf(position), taskID, status);
    }

    @Override
    public int setACState(int position, int taskID, int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setACState(SeatPosition.valueOf(position), taskID, status);
    }

    @Override
    public int setACTemperature(ACTempData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setACTemperature(data);
    }

    @Override
    public int setACCirculationMode(int position, int taskID, int mode) throws RemoteException {
        return mICarSceneModeManagerSDK.setACCirculationMode(SeatPosition.valueOf(position), taskID, mode);
    }

    @Override
    public int setACBlowLevel(BlowLeveInfo data) throws RemoteException {
        return mICarSceneModeManagerSDK.setACBlowLevel(data);
    }

    @Override
    public int setACBlowMode(BlowModeInfo data) throws RemoteException {
        return mICarSceneModeManagerSDK.setACBlowMode(data);
    }

    @Override
    public int setACDefogState(int taskID, int state) throws RemoteException {
        return mICarSceneModeManagerSDK.setACDefogState(taskID, state);
    }

    @Override
    public int setACAirAutoCleanState(int taskID, int state) throws RemoteException {
        return mICarSceneModeManagerSDK.setACAirAutoCleanState(taskID, state);
    }

    @Override
    public int setACAirForceCleanState(int taskID, int state) throws RemoteException {
        return mICarSceneModeManagerSDK.setACAirForceCleanState(taskID, state);
    }

    @Override
    public int setFragranceData(FragranceData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setFragranceData(data);
    }

    @Override
    public int setAirOutLetBladeMode(AirOutLetInfo data) throws RemoteException {
        return mICarSceneModeManagerSDK.setAirOutLetBladeMode(data);
    }

    @Override
    public int setDoorLockData(DoorLockInfo data) throws RemoteException {
        return mICarSceneModeManagerSDK.setDoorLockData(data);
    }

    @Override
    public int setUpDownAdjustData(UpDownMoveData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setUpDownAdjustData(data);
    }

    @Override
    public int setFrontRearAdjustData(FrontRearMoveData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setFrontRearAdjustData(data);
    }

    @Override
    public int setBackrestAngleAdjustData(BackrestAngleAdjustData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setBackrestAngleAdjustData(data);
    }

    @Override
    public int setCushionAdjustData(CushionAdjustData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setCushionAdjustData(data);
    }

    @Override
    public FrontRearMoveData getFrontRearAdjustData() throws RemoteException {
        return mICarSceneModeManagerSDK.getFrontRearAdjustData();
    }

    @Override
    public UpDownMoveData getUpDownAdjustData() throws RemoteException {
        return mICarSceneModeManagerSDK.getUpDownAdjustData();
    }

    @Override
    public BackrestAngleAdjustData getBackrestAngleAdjustData() throws RemoteException {
        return mICarSceneModeManagerSDK.getBackrestAngleAdjustData();
    }

    @Override
    public CushionAdjustData getCushionAdjustData() throws RemoteException {
        return mICarSceneModeManagerSDK.getCushionAdjustData();
    }

    @Override
    public int getSeatOccupyState(int position) throws RemoteException {
        return mICarSceneModeManagerSDK.getSeatOccupyState(CarPosition.valueOf(position));
    }

    @Override
    public int setSeatVentState(SeatSetData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setSeatVentState(data);
    }

    @Override
    public int setSeatHeatState(SeatSetData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setSeatHeatState(data);
    }

    @Override
    public HeatInfoData getSeatHeatInfo() throws RemoteException {
        return mICarSceneModeManagerSDK.getSeatHeatInfo();
    }

    @Override
    public VentInfoData getSeatVentInfo() throws RemoteException {
        return mICarSceneModeManagerSDK.getSeatVentInfo();
    }

    @Override
    public int getSeatHeatLevel(int position) throws RemoteException {
        return mICarSceneModeManagerSDK.getSeatHeatLevel(SeatPosition.valueOf(position));
    }

    @Override
    public int setMassageData(SeatMassageData data) throws RemoteException {
        return mICarSceneModeManagerSDK.setMassageData(data);
    }

    @Override
    public int setAutoLightStatus(int taskID, int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setAutoLightStatus(taskID, status);
    }

    @Override
    public int getAutoLightStatus() throws RemoteException {
        return mICarSceneModeManagerSDK.getAutoLightStatus();
    }

    @Override
    public int setLowBeamStatus(int taskID, int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setLowBeamStatus(taskID, status);
    }

    @Override
    public int setHighBeamStatus(int taskID, int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setHighBeamStatus(taskID, status);
    }

    @Override
    public int getSeatOccupyStatus(int pos) throws RemoteException {
        return mICarSceneModeManagerSDK.getSeatOccupyStatus(SeatPosition.valueOf(pos));
    }

    @Override
    public int setACAutoModeState(int position, int taskID, int state) {
        return mICarSceneModeManagerSDK.setACAutoModeState(SeatPosition.valueOf(position), taskID, state);
    }

    @Override
    public int setAmbientLamp(AmbientData data) {
        return mICarSceneModeManagerSDK.setAmbientLamp(data);
    }

    @Override
    public int setRemoteACState(int position, int status, int taskID) throws RemoteException {
        return mICarSceneModeManagerSDK.setRemoteACState(SeatPosition.valueOf(position), status, taskID);
    }

    @Override
    public int getRemoteACState(int position) throws RemoteException {
        return mICarSceneModeManagerSDK.getRemoteACState(SeatPosition.valueOf(position));
    }

    @Override
    public int setSceneModeStatus(int mode) throws RemoteException {
        return mICarSceneModeManagerSDK.setSceneModeStatus(mode);
    }

    @Override
    public int getSceneModeStatus() throws RemoteException {
        return mICarSceneModeManagerSDK.getSceneModeStatus();
    }

    @Override
    public int setSeatPositionMemoryStatus(int position, int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setSeatPositionMemoryStatus(SeatPosition.valueOf(position), status);
    }

    @Override
    public int setBonusEggStatus(int status) throws RemoteException {
        return mICarSceneModeManagerSDK.setBonusEggStatus(status);
    }

    @Override
    public int setScreenFoldState(int state) {
        return mICarSceneModeManagerSDK.setScreenFoldState(state);
    }

    @Override
    public int getScreenFoldState() {
        return mICarSceneModeManagerSDK.getScreenFoldState();
    }

    @Override
    public boolean getRearScreenState(int position) {
        return mICarSceneModeManagerSDK.getRearScreenState(position);
    }

    @Override
    public int setSceneModeState(int mode) {
        return mICarSceneModeManagerSDK.setSceneModeState(mode);
    }

    @Override
    public int setSceneModePhase(int mode, int status) {
        return mICarSceneModeManagerSDK.setSceneModePhase(mode, status);
    }

    @Override
    public int setScreenFoldDisableState(int status) {
        return mICarSceneModeManagerSDK.setScreenFoldDisableState(status);
    }

    @Override
    public int getScreenFoldDisableState() {
        return mICarSceneModeManagerSDK.getScreenFoldDisableState();
    }

    @Override
    public RemotFeedbackACState getRemoteACStatus(int position) throws RemoteException {
        return mICarSceneModeManagerSDK.getRemoteACStatus(SeatPosition.valueOf(position));
    }

    @Override
    public int setSceneModeOpenState(int[] status) throws RemoteException {
        return mICarSceneModeManagerSDK.setSceneModeOpenState(status);
    }

    @Override
    public int setPadSceneModeStatus(int status) {
        return mICarSceneModeManagerSDK.setPadSceneModeStatus(status);
    }

    @Override
    public int setPadBonusEggPhase(int phase) {
        return mICarSceneModeManagerSDK.setPadBonusEggPhase(phase);
    }

    @Override
    public int setPadSleepTime(int time) {
        return mICarSceneModeManagerSDK.setPadSleepTime(time);
    }

    @Override
    public void setSceneModeChangedListener(ICarSceneModeChangedListener listener) {
        this.iCarSceneModeChangedListener = listener;
    }

}
